import { PrismaClient, UserTier } from '@prisma/client'

const prisma = new PrismaClient()

/**
 * 获取指定等级的日收益率
 * @param tier 用户等级
 * @returns 日收益率（如 0.002 表示 0.2%）
 */
export async function getTierDailyRate(tier: UserTier): Promise<number> {
  try {
    const tierConfig = await prisma.tierConfig.findUnique({
      where: { tier },
      select: { dailyRate: true }
    })

    if (!tierConfig) {
      console.warn(`等级 ${tier} 的配置不存在，使用默认收益率 0.002 (0.2%)`)
      return 0.002 // 默认日收益率 0.2%
    }

    return Number(tierConfig.dailyRate)
  } catch (error) {
    console.error(`获取等级 ${tier} 的收益率失败:`, error)
    return 0.002 // 发生错误时返回默认收益率
  }
}

/**
 * 获取用户的日收益率（根据用户当前等级）
 * @param userId 用户ID
 * @returns 日收益率（如 0.002 表示 0.2%）
 */
export async function getUserDailyRewardRate(userId: number): Promise<number> {
  try {
    // 1. 查询用户的会员等级
    const user = await prisma.user.findUnique({
      where: { id: userId },
      select: { tier: true }
    })

    if (!user) {
      console.warn(`用户 ${userId} 不存在，使用默认等级 ENTRY 的收益率`)
      return await getTierDailyRate('ENTRY')
    }

    // 2. 查询该等级的日收益率配置
    return await getTierDailyRate(user.tier)
  } catch (error) {
    console.error(`获取用户 ${userId} 的收益率失败:`, error)
    return 0.002 // 发生错误时返回默认收益率
  }
}

/**
 * 根据投资金额自动计算应该升级到的等级
 * @param totalInvestment 总投资金额（NEAR）
 * @returns 应该分配的等级
 */
export async function calculateTierByInvestment(totalInvestment: number): Promise<UserTier> {
  try {
    // 查询所有激活的等级配置，按最小投资额降序排列
    const tiers = await prisma.tierConfig.findMany({
      where: { isActive: true },
      orderBy: { minInvestment: 'desc' }
    })

    // 找到符合条件的最高等级
    const eligibleTier = tiers.find(t => totalInvestment >= Number(t.minInvestment))

    if (eligibleTier) {
      return eligibleTier.tier
    }

    // 如果没有符合的等级，返回默认等级 ENTRY
    return 'ENTRY'
  } catch (error) {
    console.error('计算投资等级失败:', error)
    return 'ENTRY'
  }
}

/**
 * 自动升级用户等级并同步更新收益率
 * @param userId 用户ID
 * @param totalInvestment 总投资金额（NEAR）
 * @returns 是否发生了等级升级
 */
export async function autoUpgradeTier(userId: number, totalInvestment: number): Promise<{
  upgraded: boolean
  oldTier: UserTier | null
  newTier: UserTier
  newDailyRate: number
}> {
  try {
    // 获取用户当前等级
    const user = await prisma.user.findUnique({
      where: { id: userId },
      select: { tier: true }
    })

    if (!user) {
      throw new Error(`用户 ${userId} 不存在`)
    }

    const oldTier = user.tier

    // 计算应该升级到的等级
    const newTier = await calculateTierByInvestment(totalInvestment)

    // 如果等级没有变化，不需要升级
    if (oldTier === newTier) {
      return {
        upgraded: false,
        oldTier,
        newTier: oldTier,
        newDailyRate: await getTierDailyRate(oldTier)
      }
    }

    // 获取新等级的收益率
    const newDailyRate = await getTierDailyRate(newTier)

    // 事务处理：同时更新用户等级和质押收益率
    await prisma.$transaction(async (tx) => {
      // 更新用户等级
      await tx.user.update({
        where: { id: userId },
        data: { tier: newTier }
      })

      // 同步更新质押收益率
      await tx.userStaking.update({
        where: { userId },
        data: { dailyRewardRate: newDailyRate }
      })
    })

    console.log(`✅ 用户 ${userId} 等级已自动升级: ${oldTier} -> ${newTier}, 新日收益率: ${(newDailyRate * 100).toFixed(2)}%`)

    return {
      upgraded: true,
      oldTier,
      newTier,
      newDailyRate
    }
  } catch (error) {
    console.error(`用户 ${userId} 自动升级等级失败:`, error)
    throw error
  }
}
